#!/usr/bin/env python
#-*- coding:utf-8 -*-

"""
    Genera un archivo de comandos para ser procesado por el modulo motor.
    Genera en base a los parametros, un conjunto de atributos, un conjunto de
        reglas con los mismos, y finalmente estimulos para intentar disparar
        alguna regla.    
"""

import random

from optparse import OptionParser

def generar_estimulos(atributos, cantidad, cardinalidad, minimo, maximo):
    """
        Genera un conjunto de estimulos con componentes del estilo:
                variable=valor
        Donde:
            - variable es seleccionada del conjunto atributos.
            - valor es un numero entero en la secuencia [minimo, maximo]
            - cantidad; cantidad de estimulos a generar.
            - cardinalidad; cantidad de atributos por estimulo.
    """
    estimulos = dict()
    for i in xrange(cantidad):
        atrs = dict()
        while len(atrs) < cardinalidad:
            valor = random.randint(minimo, maximo)
            atrs[ random.choice(atributos) ] = str(valor)
        estimulo = ''
        for atr, val in atrs.items():
            estimulo += ' '+atr+'='+val

        if estimulo not in estimulos:
            estimulos[estimulo] = 'e'+str(i)
    return estimulos

def imprimir(atributos, reglas, estimulos):
    """
        Imprime los atributos, reglas y estimulos indicados en el formato
            requerido por el modulo motor.        
    """

    if len(atributos)*len(reglas)*len(estimulos) < 100:
        print 'eco:'

    print 'entrenar:'
    print '#Atributos:'
    for atributo in atributos:
        print 'atributo: '+atributo

    print ''
    print '#Reglas:'
    for regla in reglas:
        print 'regla: '+regla

    print ''
    #print 'producir:'
    print ''
    print '#Estimulos:'
    for estimulo, nombre in estimulos.items():
        print 'hecho: '+nombre+' '+estimulo

    print ''
    print 'estado:'


def main():
    """
        Intrepretacion de parametros y creacion del archivo de prueba.
    """
        
    # Interpretar
    parser = OptionParser(usage = '%prog [sarcemM]')
#   parser.add_option('-h', '--help', help='Mostrar un mensaje de ayuda.')
    parser.add_option('-s', '--semilla', type='int',
                        help='Definir la semilla del generador aletario.',
                        dest='semilla', default=None)
    parser.add_option('-a', '--atributos', type='int',
                        help='Cantidad de atributos a utilizar.',
                        dest='atributos', default=2)
    parser.add_option('-r', '--reglas', type='int',
                        help='Cantidad de reglas a generar.',
                        dest='reglas', default=3)
    parser.add_option('-c', '--cardinalidad', type='int',
                        help='Cantidad de condiciones que tiene cada regla.',
                        dest='cardinalidad', default=1)
    parser.add_option('-e', '--estimulos', type='int',
                        help='Cantidad de estimulos a generar.',
                        dest='estimulos', default=10)
    parser.add_option('-m', '--minimo', type='int',
                        help='Numero minimo de los valores de las constantes.',
                        dest='minimo', default=0)
    parser.add_option('-M', '--Maximo', type='int',
                        help='Numero maximo de los valores de las constantes.',
                        dest='Maximo', default=0)

    (opts, args) = parser.parse_args()

    if len(args):
        print 'Obviando los argumentos: '+str(args)
        
    random.seed(opts.semilla)

    atributos = list()
    for nro in xrange(opts.atributos):
        atributos.append('X'+str(nro))

    reglas = set()
    # Genero reglas de igualdad, para X atributos distintos.
    for nro in xrange(opts.reglas):
        regla = list()
        usados = list()
        # cardinalidad de una regla es la cantidad de atributos que tiene.
        while len(regla) < opts.cardinalidad:
            usados.append( random.choice(atributos) )

            regla_str = '('+usados[-1]
            regla_str += ' '+random.choice(('=', '!=', '<', '>'))+' '
#           regla_str += ' '+random.choice(('=', '!='))
            regla_str += str(random.randint(opts.minimo, opts.Maximo)) + ')'
                
            if len(usados) < opts.cardinalidad:
                regla_str += random.choice((' & ', ' | ')) 

            regla.append(regla_str)

        reglas.add(' '.join(regla))

    reglas.add('3 > (X0+X1)')
    reglas.add('X0+X1 < 3')

    # Genero estimulos.
    estimulos = generar_estimulos(atributos, opts.estimulos, opts.cardinalidad,
                                  opts.minimo, opts.Maximo)


    imprimir(atributos, reglas, estimulos)


if __name__ == '__main__':
    main()
